home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1994 November / macformat-018.iso / Utility Spectacular / Developer / macgambit-20-compiler-src-p1 / Runtime (.c & .h) / os_mac_eKeys.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-26  |  16.2 KB  |  650 lines  |  [TEXT/KAHL]
  1. /* os_mac_eKeys.c
  2.  * 3May92  e
  3.  */
  4.  
  5. #include "os_mac_eEdit.h"
  6.  
  7. /* extensions to an editor for text files by e
  8.    questions/comments via Internet <e@Flavors.COM> */
  9. /* Copyright © e, 1989,1992. All rights reserved.
  10.     Developed using THINK C 5.0.1 for use with Gambit Scheme.
  11.     This code may be freely distributed as long as this notice remains.
  12.    balance_bwd was written by Marc Feeley.
  13. */
  14.  
  15. #define graphic_char(c) (!(((c)>=0) && ((c)<=32)))
  16.  
  17. static long whsp_fwd_guts( eRec **hE, long offs )
  18. { 
  19.   register char *text = *((**hE).hText);
  20.   register char *p = text + offs;
  21.   register char *end = text + eTeTextLength( hE );
  22.   register char c;
  23.  
  24.   while( p < end )
  25.   { c = *p++;
  26.     if( graphic_char(c) )
  27.     { if( c != ';' )
  28.           return p - text - 1;
  29.       else
  30.         while ( p < end && *p++ != '\r' )  ;
  31.     }
  32.   }
  33.   return end - text;
  34. }
  35.  
  36. static long whsp_fwd( eRec **hE )
  37. { 
  38.   long offs = eTeChPosToOffset( hE, (**hE).selActive ? (**hE).selEnd : (**hE).caretChPos );
  39.   return whsp_fwd_guts( hE, offs );
  40. }
  41.  
  42. static long whsp_bwd( eRec **hE )
  43. {
  44.   long offs = eTeChPosToOffset( hE, (**hE).selActive ? (**hE).selStart : (**hE).caretChPos );
  45.   register char *text = *((**hE).hText);
  46.   register char *p = text + offs - 1;
  47.   register char c;
  48.  
  49.   while( p >= text )
  50.   { if( graphic_char( *p ) )
  51.         return p - text + 1;
  52.     else
  53.       p--;
  54.   }
  55.   return 0;
  56. }
  57.  
  58. long balance_fwd_guts( eRec **hE, long offs, int bal )
  59. { 
  60.   register char *text = *((**hE).hText);
  61.   register char *p = text + offs;
  62.   register char *end = text + eTeTextLength( hE );
  63.   register int b = bal;
  64.   register char c;
  65.  
  66.   while( p < end && !graphic_char(*p) ) p++;
  67.  
  68.   while( p < end )
  69.   { c = *p++;
  70.     if( graphic_char(c) )
  71.       switch (c)
  72.       { case '(':
  73.           b++;
  74.           break;
  75.         case ')':
  76.           b--;
  77.           if (b <= 0) goto scan_done;
  78.           break;
  79.         case ';':
  80.           while ( p < end && *p++ != '\r' )  ;
  81.           break;
  82.         case '"':
  83.         { while (p<end)
  84.           { c = *p++;
  85.               if( c == '"' ) goto breake;
  86.               if( c == '\\' ) p++;
  87.           }
  88.           return -1;
  89.           breake:
  90.           if( b <= 0 ) goto scan_done;
  91.           break;
  92.         }
  93.         case '#':
  94.           if( *p == '\\' ) p += 2;
  95.           break;
  96.         case ',':
  97.           if( *p == '@' ) p++;
  98.           break;
  99.         case '\'':
  100.         case '`':
  101.           break;
  102.         default:
  103.         { while ((p<=end) && graphic_char(c) && (c!='(') && (c!=')') && (c!='"'))
  104.             c = *p++;
  105.           p--;
  106.           if (b <= 0) goto scan_done;
  107.           break;
  108.         }
  109.      }
  110.   }
  111.   return -1;
  112.  
  113.   scan_done:
  114.   return p-text;
  115. }
  116.  
  117. long balance_fwd( eRec **hE, int bal )
  118. { 
  119.   long offs = eTeChPosToOffset( hE, (**hE).selActive ? (**hE).selEnd : (**hE).caretChPos );
  120.   return balance_fwd_guts( hE, offs, bal );
  121. }
  122.  
  123. static long balance_bwd_guts( eRec **hE, long offs, int bal, int prefix )
  124. {
  125.   register char *text = *((**hE).hText);
  126.   register char *p = text + offs;
  127.   register int b = bal;
  128.  
  129.   while ((p>text) && !graphic_char(p[-1])) p--;
  130.  
  131.   while (p>text)
  132.     if ((p>=text+3) && (p[-2]=='\\') && (p[-3]=='#'))
  133.     { p -= 3;
  134.       if (b <= 0) goto scan_prefix;
  135.     }
  136.     else
  137.     { register char c = *--p;
  138.       if (graphic_char(c))
  139.         switch (c)
  140.         { case '(':
  141.             b--;
  142.             if (b <= 0) goto scan_prefix;
  143.             break;
  144.           case ')':
  145.             b++;
  146.             break;
  147.           case '"':
  148.           { while (p>text)
  149.             { register char *q = --p;
  150.               while ((q>text) && (q[-1]=='\\')) q--;
  151.               if ((p-q)&1L)
  152.                 p = q;
  153.               else if (*p=='"')
  154.                 if (b <= 0) goto scan_prefix; else goto brak;
  155.             }
  156.             return -1;
  157.             brak:
  158.             break;
  159.           }
  160.           default:
  161.           { while ((p>=text) && graphic_char(c) &&
  162.                    (c!='(') && (c!=')') && (c!='"'))
  163.               c = *--p;
  164.             p++;
  165.             if (b <= 0) goto scan_prefix;
  166.             break;
  167.           }
  168.       }
  169.   }
  170.   return -1;
  171.  
  172.   scan_prefix:
  173.   if (prefix)
  174.     while (p>text)
  175.     { register char c = *--p;
  176.       if ((c!='\'') && (c!='`') && (c!=',') && (c!='@') && (c!='#'))
  177.       { p++; break; }
  178.     }
  179.   return p-text;
  180. }
  181.  
  182. long balance_bwd( eRec **hE, int bal, int prefix )
  183. {
  184.   long offs = eTeChPosToOffset( hE, (**hE).selActive ? (**hE).selStart : (**hE).caretChPos );
  185.   return balance_bwd_guts( hE, offs, bal, prefix );
  186. }
  187.  
  188. static int rangeBalance( register char *beg, register char *end )
  189. {
  190.     register int n = 0;
  191.     
  192.     while(beg < end)
  193.     {    if (*beg == '(')        n++;
  194.         else if (*beg == ')')    n--;
  195.         beg++;
  196.     }
  197.     return(n);
  198. }
  199.  
  200. /* 23Jul92  e  */
  201.  
  202. extern int check_TEInsert( char *ptr, long len, eRec **hE, int bold );
  203.  
  204. #if 0
  205.  
  206. /* 17Aug92  e  */
  207.  
  208. void eTabCommand( eRec **hE, short modifiers, short style )
  209. { long open_paren;
  210.   long selStart, selEnd, selLen;
  211.   ChPos solcp, eolcp;
  212.   char *p;
  213.   long sol, eol;
  214.   long adj = 0;
  215.   Boolean selActive;
  216.  
  217.   if( ( selActive = (**hE).selActive ) )
  218.   {    selStart = eTeChPosToOffset( hE, (**hE).selStart );
  219.     selEnd   = eTeChPosToOffset( hE, (**hE).selEnd );
  220.     selLen   = selEnd - selStart;
  221.     eTeSetSelect( hE, selStart, selStart );
  222.     solcp = (**hE).selStart;
  223.   }
  224.   else
  225.   {    selStart = eTeChPosToOffset( hE, (**hE).caretChPos );
  226.     selLen = 0;
  227.     solcp = (**hE).caretChPos;
  228.   }
  229.   eolcp.h = solcp.h = 0;    /* start of line */
  230.   eolcp.v = solcp.v + 1;
  231.   eol = eTeChPosToOffset( hE, eolcp );    /* next line */
  232.   sol = eTeChPosToOffset( hE, solcp );    /* this line */
  233.   p = *((**hE).hText) + sol;
  234.   while( ! graphic_char( *p ) && sol < eol && *p != RETURN ) { p++; sol++; solcp.h++; }
  235.   if( sol != selStart ) eTeSetSelect( hE, sol, sol );
  236.   if( sol < selStart )  adj = selStart - sol;
  237.   
  238.   open_paren = balance_bwd( hE, 0, 1 );
  239.   eolcp = eTeOffsetToChPos( hE, open_paren );
  240.   if( solcp.h > eolcp.h )
  241.   { eolcp.v = solcp.v;
  242.     eol = eTeChPosToOffset( hE, eolcp );
  243.     eTeSetSelect( hE, eol, eol );
  244.     eTeKillTo( hE, solcp );
  245.   }
  246.   else while (solcp.h < eolcp.h)
  247.   { long len = (eolcp.h - solcp.h < 80) ? eolcp.h - solcp.h : 80;
  248.     if (check_TEInsert( "                                                                                ",
  249.                         len, hE, style )) goto err;
  250.     solcp.h += len;
  251.   }
  252.   err:
  253.   if( sol < selStart || selActive )
  254.   { selStart = eTeChPosToOffset( hE, (**hE).caretChPos ) + adj;
  255.     eTeSetSelect( hE, selStart, selStart + selLen );
  256.   }
  257.   eTeShowCaret( hE );
  258. }
  259.  
  260. #else
  261.  
  262. /* 14Oct92  e  */
  263.  
  264. static char dncase( char c )
  265. { if( c >= 'A' &&  c <= 'Z' ) return c + 0x20;
  266.   else return c;
  267. }
  268.  
  269. static Boolean eq_subfs( char *p, char *q )
  270. { char c;
  271.   while( c = *p++ )
  272.     if( c != dncase( *q++ ) )
  273.       return FALSE;
  274.   c = *q;
  275.   return( ( graphic_char(c) && c != '(' && c != '"' ) ? FALSE : TRUE );
  276. }
  277.  
  278. /* subforms of forms whose car is in this table are indented specially...
  279.   call the subform to be indented "the target":
  280.   if there are more than cnt subforms between the car and the target,
  281.     then the last subform before the target determines the postion of the target,
  282.   otherwise the target is indented one more space than the car
  283. */ 
  284.  
  285. struct _spec_subfs { char *str; char cnt; };
  286.  
  287. static struct _spec_subfs spec_subfs_data[] =
  288.     { { "if", 1 },
  289.       { "do", 2 },
  290.       { "do*", 2 },
  291.       { "let", 18 },    /* special case for named let */
  292.       { "let*", 1 },
  293.       { "case", 1 },
  294.       { "begin", 0 },
  295.       { "lambda", 1 },
  296.       { "letrec", 1 },
  297.       { "define", 1 },
  298.       { "##declare", 0 },
  299.       { "##define-macro", 1 },
  300.       { "", -1 }
  301.     };
  302.  
  303. static long spec_subfs( char *p )
  304. { char c;
  305.   long res = -1;
  306.   struct _spec_subfs *s = spec_subfs_data;
  307.   if( (c = dncase(*p)) >= 'a' && c <= 'z' )
  308.     while( (res = (*s).cnt) >= 0 )
  309.       if( eq_subfs( (*s).str, p ) )
  310.         break;
  311.       else
  312.         s++;
  313.   return res;
  314. }
  315.  
  316. void eTabCommand( eRec **hE, short modifiers, short style )
  317. { long open_paren, upen_paren;
  318.   long selStart, selEnd, selLen;
  319.   ChPos solcp, eolcp;
  320.   char *p;
  321.   long sol, eol;
  322.   long adj = 0;
  323.   Boolean selActive;
  324.   
  325.   if( ( selActive = (**hE).selActive ) )
  326.   {    selStart = eTeChPosToOffset( hE, (**hE).selStart );
  327.     selEnd   = eTeChPosToOffset( hE, (**hE).selEnd );
  328.     selLen   = selEnd - selStart;
  329.     eTeSetSelect( hE, selStart, selStart );
  330.     solcp = (**hE).selStart;
  331.   }
  332.   else
  333.   {    selStart = eTeChPosToOffset( hE, (**hE).caretChPos );
  334.     selLen = 0;
  335.     solcp = (**hE).caretChPos;
  336.   }
  337.   eolcp.h = solcp.h = 0;    /* start of line */
  338.   eolcp.v = solcp.v + 1;
  339.   eol = eTeChPosToOffset( hE, eolcp );    /* next line */
  340.   sol = eTeChPosToOffset( hE, solcp );    /* this line */
  341.   p = *((**hE).hText) + sol;
  342.   while( ! graphic_char( *p ) && sol < eol && *p != RETURN ) { p++; sol++; solcp.h++; }
  343.   if( sol != selStart ) eTeSetSelect( hE, sol, sol );
  344.   if( sol < selStart )  adj = selStart - sol;
  345.   
  346.   open_paren = balance_bwd_guts( hE, sol, 0, 1 );
  347.   /*  14Oct92  e  */
  348.   if( open_paren > 0 )
  349.   { upen_paren = balance_bwd_guts( hE, sol, 1, 1 );
  350.     if( upen_paren < 0 )
  351.     { /* a toplevel form should be at column zero !? */
  352.       eolcp.h = 0;
  353.       goto justdotab;
  354.     }
  355.     else
  356.     { long rover, prevr, first;
  357.       long count = 0;
  358.       char *text = *((**hE).hText);
  359.       p = text + upen_paren;
  360.       while( *p != '(' ) p++;    /* there must be a '(' since upen_paren >= 0 */ 
  361.       upen_paren = p - text;    /* the offset of the '(' */
  362.       prevr = upen_paren + 1;
  363.       rover = first = whsp_fwd_guts( hE, prevr );
  364.       while( rover > 0 && rover < open_paren )
  365.       { prevr = rover;
  366.           count++;
  367.         rover = balance_fwd_guts( hE, rover, 0 );
  368.         if( rover > 0 ) rover = whsp_fwd_guts( hE, rover );
  369.       }
  370.       /* now...
  371.         upen_paren = start of enclosing form
  372.         open_paren = start of preceeding form
  373.         first = first sub-form of enclosing form
  374.         prevr = last sub-form of enclosing form <= open_paren, or upen_paren+1 if none
  375.         rover = last sub-form of enclosing form >= open_paren, or -1 if none
  376.         count = position of rover in subforms of enclosing form
  377.       */ /* this catches subforms inside comments... */
  378.       if( rover != open_paren ) { open_paren = prevr; count--; }
  379.       /* this handles special indentation for special forms... */
  380.       if( first < sol
  381.           && (rover = spec_subfs( text + first ) ) >= 0
  382.           && ( count == 0 || count == rover || ( rover > 15 && count <= (rover&15)) ) )
  383.       { eolcp = eTeOffsetToChPos( hE, first );
  384.           eolcp.h += 1;
  385.           goto justdotab;
  386.       }
  387.     }
  388.   }
  389.   /* */
  390.   eolcp = eTeOffsetToChPos( hE, open_paren );
  391. justdotab:
  392.   if( solcp.h > eolcp.h )
  393.   { eolcp.v = solcp.v;
  394.     eol = eTeChPosToOffset( hE, eolcp );
  395.     /* 27Jan93  e  -- this mungs the scrap...
  396.     eTeSetSelect( hE, eol, eol );
  397.     eTeKillTo( hE, solcp );
  398.     instead... */
  399.     eTeSetSelect( hE, eol, sol );
  400.     eTeDelete( hE );
  401.   }
  402.   else while (solcp.h < eolcp.h)
  403.   { long len = (eolcp.h - solcp.h < 80) ? eolcp.h - solcp.h : 80;
  404.     if (check_TEInsert( "                                                                                ",
  405.                         len, hE, style )) goto err;
  406.     solcp.h += len;
  407.   }
  408.   err:
  409.   if( sol < selStart || selActive )
  410.   { selStart = eTeChPosToOffset( hE, (**hE).caretChPos ) + adj;
  411.     eTeSetSelect( hE, selStart, selStart + selLen );
  412.   }
  413.   eTeShowCaret( hE );
  414. }
  415.  
  416. #endif
  417.  
  418. #define mCheck(n, ch) ((rover[n] == ch) && (n >= 0) && (n < teLength))
  419.  
  420. void eEditCommand( eRec **hE, char ch, short modifiers, short style )
  421. {
  422.     register char *rover;
  423.     register long needLeft, needRight;
  424.     long selStart, selEnd, teLength;
  425.     short wanted;    /* -1 at start, 0 range, 1 at end */
  426.     Boolean selActive;
  427.     short optioned = modifiers & optionKey;
  428.     short shifted  = modifiers & shiftKey;
  429.     
  430.     ch += 0x40;    /* undo control key */
  431.     modifiers &= ~controlKey;
  432.     
  433.     if( ( selActive = (**hE).selActive ) )
  434.     {    selStart = eTeChPosToOffset( hE, (**hE).selStart );
  435.         selEnd =   eTeChPosToOffset( hE, (**hE).selEnd );
  436.     }
  437.     else
  438.     {    selEnd = selStart = eTeChPosToOffset( hE, (**hE).caretChPos );
  439.     }
  440.     teLength = eTeTextLength( hE );
  441.     
  442.     rover = (char *)*(**hE).hText;
  443.     wanted = 0;                        /* always range; someday use mark */
  444.     needLeft = needRight = 0;
  445.  
  446.     switch( ch )
  447.     {
  448.         case 'T':            /* Transpose */        /* 22Jul92  e  */
  449.         case 't':
  450.         case '†':    /* option-t */
  451.         case 'ˇ':    /* option-shift-t */
  452.             if( selActive )
  453.               SysBeep(6);
  454.             else if( optioned )
  455.             { needLeft  = balance_bwd( hE, 0, 1 );
  456.               needRight = balance_fwd( hE, 0 );
  457.               if( needLeft >= 0 && needRight >= 0 )
  458.                 eTeTranspose( hE, needLeft, whsp_bwd( hE ), whsp_fwd( hE ), needRight );
  459.               else
  460.                 SysBeep(6); /* can't be done! */
  461.             }
  462.             else
  463.               eTeTranspose( hE, selStart - 1, selStart, selStart, selStart + 1 );
  464.             return;
  465.  
  466.         case 'K':            /* Kill */
  467.         case 'k':
  468.         case '':    /* option-k */
  469.         case '˚':    /* option-shift-k */
  470.             if( ! selActive && optioned )
  471.             { /* c-m-k (del-fwd-sexp) */
  472.               selEnd = balance_fwd( hE, 0 );
  473.               if( selEnd >= 0 )
  474.               { eTeKillTo( hE, eTeOffsetToChPos( hE, selEnd ) );
  475.               }
  476.               else SysBeep( 3 );
  477.             }
  478.             else /* Kill line */
  479.               eTeKey( hE, 0x7f, KeyDel, optionKey, style);
  480.             return;
  481.  
  482.         case 'D':            /* Delete */
  483.         case 'd':
  484.             eTeKey( hE, 0x7f, KeyDel, 0, style);
  485.             return;
  486.  
  487.         case 'O':            /* Open line */
  488.         case 'o':
  489.         case 'ø':    /* option-o */
  490.         case 'Ø':    /* option-shift-o */
  491.             if( selActive )
  492.                 eTeSetSelect( hE, selStart, selStart );
  493.             eTeKey( hE, '\r', 0, 0, style);
  494.             eTeSetSelect( hE, selStart, selStart );
  495.             return;
  496.  
  497.         case 'A':
  498.         case 'a':
  499.         case 'å':    /* option-a */
  500.         case 'Å':    /* option-shift-a */
  501.             if( optioned )
  502.             {    wanted = shifted ? 0 : -1;
  503.                 needLeft = 2;
  504.                 /* needRight = 2; */
  505.                 break;
  506.             }
  507.             eTeKey( hE, LEFT_ARROW, 0, modifiers | cmdKey, style );
  508.             return;
  509.  
  510.         case 'E':
  511.         case 'e':
  512.                     /* option-e is a dead key */
  513.         case '´':    /* option-shift-e */
  514.             if( optioned )
  515.             {    wanted = shifted ? 0 : 1;
  516.                 /* needLeft = 2; */
  517.                 needRight = 2;
  518.                 break;
  519.             }
  520.             eTeKey( hE, RIGHT_ARROW, 0, modifiers | cmdKey, style );
  521.             return;
  522.  
  523.         case 'P':                            /* Previous */
  524.         case 'p':
  525.         case 'π':    /* option-p */
  526.         case '∏':    /* option-shift-p */
  527.             eTeKey( hE, UP_ARROW, 0, modifiers, style );
  528.             return;
  529.  
  530.         case 'N':                            /* Next */
  531.         case 'n':
  532.                     /* option-n is a dead key */
  533.         case '˜':    /* option-shift-n */
  534.             eTeKey( hE, DOWN_ARROW, 0, modifiers, style );
  535.             return;
  536.  
  537.         case 'M':                            /* Match (Balance) */
  538.         case 'm':
  539.         case 'µ':    /* option-m */
  540.         case 'Â':    /* option-shift-m */
  541.             if( ! selActive )
  542.             {    /* too smart?  22Jul92  e
  543.                 if( mCheck( selStart, '(' ) )
  544.                 {    selEnd = selStart + 1;
  545.                     needLeft = 0;
  546.                     needRight = 1;
  547.                 }
  548.                 else if( mCheck( selStart - 1, ')' ) )
  549.                 {    selStart = selEnd - 1;
  550.                     needLeft = 1;
  551.                     needRight = 0;
  552.                 }
  553.                 else
  554.                 {    needLeft = 1;
  555.                     needRight = 1;
  556.                 }
  557.                 */
  558.                 needLeft = 2;
  559.                 needRight = 2;
  560.             }
  561.             else
  562.             {    needRight = rangeBalance( &rover[selStart], &rover[selEnd] );
  563.                 /* too smart?  22Jul92  e
  564.                 if( needRight == 0 )
  565.                 {    needLeft = 1;
  566.                     needRight = 1;
  567.                 }
  568.                 else if( needRight < 0 )
  569.                 {    needLeft = -needRight;
  570.                     if( mCheck(selEnd - 1, ')' ) )
  571.                         needRight = 0;
  572.                     else
  573.                     {    needRight = 1;
  574.                         needLeft += 1;
  575.                     }
  576.                 }
  577.                 else
  578.                 {    if( mCheck( selStart, '(' ) )
  579.                         needLeft = 0;
  580.                     else
  581.                     {    needLeft = 1;
  582.                         needRight += 1;
  583.                     }
  584.                 }
  585.                 */
  586.                 if( needRight == 0 )
  587.                 {    needLeft = 2;
  588.                     needRight = 2;
  589.                 }
  590.                 else if( needRight < 0 )
  591.                 {    needLeft = -needRight;
  592.                     needRight = 2;
  593.                     needLeft += 2;
  594.                 }
  595.                 else
  596.                 {    needLeft = 2;
  597.                     needRight += 2;
  598.                 }
  599.             }
  600.             break;
  601.  
  602.         case 'ƒ':    /* option f */                /* Forward */
  603.         case 'f':
  604.         case 'Ï':    /* option shift f */
  605.         case 'F':
  606.             wanted = shifted ? 0 : 1;
  607.             if( ! selActive || shifted )
  608.             {    if( optioned ) needRight = 1;
  609.                 else
  610.                 {    eTeKey( hE, RIGHT_ARROW, 0, modifiers, style );
  611.                     return;
  612.                 }
  613.             }
  614.             /* else    selection range case automatic */
  615.             break;
  616.  
  617.         case '∫':    /* option b */                /* Back */
  618.         case 'b':
  619.         case 'ı':    /* option shift b */
  620.         case 'B':
  621.             wanted = shifted ? 0 : -1;
  622.             if( ! selActive || shifted )
  623.             {    if( optioned ) needLeft = 1;
  624.                 else
  625.                 {    eTeKey( hE, LEFT_ARROW, 0, modifiers, style );
  626.                     return;
  627.                 }
  628.             }
  629.             /* else    selection range case automatic */
  630.             break;
  631.  
  632.         default:
  633.             return;
  634.     }
  635.     if( needRight != 0 )
  636.     {     selEnd   = balance_fwd( hE, needRight - 1 );
  637.         if( selEnd   < 0 ) { SysBeep(6); return; } /* can't be done! */
  638.     }
  639.     if( needLeft  != 0 )
  640.     {     selStart = balance_bwd( hE, needLeft  - 1, 1 );
  641.         if( selStart < 0 ) { SysBeep(6); return; } /* can't be done! */
  642.     }
  643.     eTeSetSelect( hE,
  644.                   (wanted ==  1) ? selEnd : selStart,
  645.                   (wanted == -1) ? selStart : selEnd  );
  646.     eTeShowCaret( hE );
  647. }
  648.  
  649. /* end of os_mac_eKeys.c */
  650.